package com.yzqp.generator.util.resolve;

import com.yzqp.generator.util.ParamMap;
import lombok.Data;

import java.util.List;

/**
 * if函数非终结符表达式
 * 　　每个非终结符表达式都代表了一个文法规则，并且每个文法规则都只关心自己周边的文法规则的结果，因此这就产生了每个非终结符表达式调用自己周边的非终结符表达式，然后最终、最小的文法规则就是终结符表达式。
 * 子类有： if表达式 for表达式
 */
@Data
public class IfFunctionNonterminalResolveExpression extends NonterminalResolveExpression {

    // 构造函数
    public IfFunctionNonterminalResolveExpression(String expressionString, ParamMap paramMap) {
        super(expressionString, paramMap);
    }

    @Override
    public String interpreter() {

        String expressionValue = this.expressionString;

        // 解析一下表达式

        // 解析字符串
        // 查看是否有if函数
        if (expressionValue.indexOf("#.{startif") > -1) {
            // 开始的下标 即 #{startif 的#的下标
            int startIndex = expressionValue.indexOf("#.{startif");
            // 结束的下标 即 #{endif} 的}的下标
            int endIndex = ResolveContext.getEndFunctionIndex(startIndex, expressionString);

            // 根据if循环的开始结束下标 切割出 已经解析的字符串 还没有解析的字符串 要解析的字符串
            String inDealString = expressionValue.substring(startIndex, endIndex + 1);


            /**
             * // 测试if
             * @startTemple
             * before
             * #{startif author == '何佳成'}
             * import ${author} - ${author1}
             * #{endif}
             * after
             */
            // 解析if函数
            // 表达式的开始下标
            int expressionStartIndex = inDealString.indexOf("#.{startif");
            expressionStartIndex = expressionStartIndex + 10;
            // 表达式的结束下标
            int expressionEndIndex = inDealString.indexOf(".}");
            expressionEndIndex = expressionEndIndex - 1;
            String expresstKey = inDealString.substring(expressionStartIndex, expressionEndIndex + 1);
            // 切割出两个key
            String[] keys = expresstKey.split("==");
            // 判断两个key的值是否相等
            String keyOne = keys[0].trim();
            String keyOneValue = "";
            // 判断是否是以 ' 开头 是的话，value 是去掉''的key
            if (keyOne.startsWith("'")) {
                keyOneValue = keyOne.substring(0, keyOne.length() - 1);
            } else {
                keyOneValue = paramMap.get(keyOne);
            }
            String keyTwo = keys[1].trim();
            String keyTwoValue = "";
            // 判断是否是以 ' 开头 是的话，value 是去掉''的key
            if (keyTwo.startsWith("'")) {
                keyTwoValue = keyTwo.substring(1, keyTwo.length() - 1);
            } else {
                keyTwoValue = paramMap.get(keyTwo);
            }

            // if的判断是 真 的
            if (keyOneValue.equals(keyTwoValue)) {
                // 解析需要if内的字符串
                int ifStartIndex = inDealString.indexOf(".}");
                ifStartIndex = ifStartIndex + 2;
                int ifEndIndex = inDealString.indexOf("#.{ifend .}") - 1;
                String expressionString = inDealString.substring(ifStartIndex, ifEndIndex + 1);
                // 重新修改开始结束标志 函数内容要包括 之前的换行符
                char[] cs = expressionString.toCharArray();
                int len = -1;
                for (int i = expressionString.length() - 1; i >= 0; i--) {
                    char c = cs[i];
                    if (c == '\n') {
                        len = i - 1;
                        break;
                    }
                }
                expressionString = new String(cs, 0, len);
                // 去除if表达式内的内容，去除左右两边的 换行 空格
//                expressionString = expressionString.trim();

                // if函数内的内容再次解析
                List<ResolveExpression> ifInnerExpressionList = ResolveContext.resolve(expressionString, paramMap);

                for (ResolveExpression resolveExpression : ifInnerExpressionList) {
                    resolveExpressionList.add(resolveExpression);
                }
            } else {
                resolveExpressionList.add(new StringTerminalResolveExpression("", paramMap));
            }


        }


        String value = "";
        for (ResolveExpression resolveExpression : resolveExpressionList) {
            value = value + resolveExpression.interpreter();
        }
        return value;
    }
}
